{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 导入需要的包"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-22T12:52:43.433037Z",
     "start_time": "2023-04-22T12:52:43.378952Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "from math import log\n",
    "import operator\n",
    "from matplotlib.font_manager import FontProperties #设置中文字体\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 根据大致的思路，定义主函数\n",
    "createDataSet()：创建一个数据集，返回数据和他对应的标签，或者直接使用pandas也可以\n",
    "featLabels：为决策树选择的标签\n",
    "createTree()：返回一个字典，表示得到的决策树\n",
    "createPlot()：传入一个表示决策树的字典，根据这个字典画出决策树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-22T12:52:43.471359Z",
     "start_time": "2023-04-22T12:52:43.388626Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    \"\"\"主函数.\"\"\"\n",
    "    dataSet, labels = createDataSet()\n",
    "    featLabels = []\n",
    "    myTree = createTree(dataSet, labels, featLabels)\n",
    "    createPlot(myTree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 创建数据"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## createDateSet\n",
    "函数说明：创建测试数据集.\n",
    "\n",
    "Returns：\n",
    ">dataSet：数据集\n",
    ">labels：分类属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-22T12:52:43.472658Z",
     "start_time": "2023-04-22T12:52:43.405548Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def createDataSet():\n",
    "    # 数据集\n",
    "    dataSet = [[0, 0, 0, 0, 'no'],\n",
    "               [0, 0, 0, 1, 'no'],\n",
    "               [0, 1, 0, 1, 'yes'],\n",
    "               [0, 1, 1, 0, 'yes'],\n",
    "               [0, 0, 0, 0, 'no'],\n",
    "               [1, 0, 0, 0, 'no'],\n",
    "               [1, 0, 0, 1, 'no'],\n",
    "               [1, 1, 1, 1, 'yes'],\n",
    "               [1, 0, 1, 2, 'yes'],\n",
    "               [1, 0, 1, 2, 'yes'],\n",
    "               [2, 0, 1, 2, 'yes'],\n",
    "               [2, 0, 1, 1, 'yes'],\n",
    "               [2, 1, 0, 1, 'yes'],\n",
    "               [2, 1, 0, 2, 'yes'],\n",
    "               [2, 0, 0, 0, 'no']]\n",
    "    # 分类属性\n",
    "    labels = ['年龄', '有工作', '有自己的房子', '信贷情况']\n",
    "    # 返回数据集和分类属性\n",
    "    return dataSet, labels\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 建立树"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## createTree\n",
    "\n",
    "Parameters:\n",
    ">    dataSet：训练数据集\n",
    ">    labels：分类属性标签\n",
    ">    featLabels：存储选择的最优特征标签\n",
    "\n",
    "Returns:\n",
    ">    myTree：决策树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-22T12:52:43.474121Z",
     "start_time": "2023-04-22T12:52:43.424014Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def createTree(dataSet, labels, featLabels):\n",
    "    \"\"\"\n",
    "    \"\"\"\n",
    "    # 取分类标签（是否放贷：yes or no）\n",
    "    classList = [example[-1] for example in dataSet]\n",
    "    # 如果类别完全相同——响应变量全部相同，则停止继续划分\n",
    "    if classList.count(classList[0]) == len(classList):\n",
    "        return classList[0]\n",
    "    # 遍历完所有特征时返回出现次数最多的类标签\n",
    "    if len(dataSet[0]) == 1:  # 只有一个响应变量，没有类可分了\n",
    "        return majorityCnt(classList)\n",
    "    # 选择最优特征\n",
    "    bestFeat = chooseBestFeatureToSplit(dataSet)\n",
    "    # 最优特征的标签\n",
    "    bestFeatLabel = labels[bestFeat]\n",
    "    featLabels.append(bestFeatLabel)\n",
    "    # 根据最优特征的标签生成树\n",
    "    myTree = {bestFeatLabel: {}}\n",
    "    # 删除已经使用的特征标签\n",
    "    del (labels[bestFeat])\n",
    "    # 得到训练集中所有最优特征的属性值\n",
    "    featValues = [example[bestFeat] for example in dataSet]\n",
    "    # 去掉重复的属性值\n",
    "    uniqueVls = set(featValues)\n",
    "    # 遍历特征，创建决策树\n",
    "    for value in uniqueVls:\n",
    "        myTree[bestFeatLabel][value] = createTree(\n",
    "            splitDataSet(dataSet, bestFeat, value),\n",
    "            labels, featLabels)\n",
    "    return myTree\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 统计classList中出现次数最多的元素（类标签）\n",
    "\n",
    "Parameters：\n",
    ">    classList：类标签列表\n",
    "\n",
    "Returns：\n",
    ">    sortedClassCount[0][0]：出现次数最多的元素（类标签）\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-22T12:52:43.482802Z",
     "start_time": "2023-04-22T12:52:43.482579Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "def majorityCnt(classList):\n",
    "    classCount = {}\n",
    "    # 统计classList中每个元素出现的次数\n",
    "    for vote in classList:\n",
    "        if vote not in classCount.keys():\n",
    "            classCount[vote] = 0\n",
    "            classCount[vote] += 1\n",
    "        # 根据字典的值降序排列\n",
    "        sortedClassCount = sorted(classCount.items(),\n",
    "                                  key=operator.itemgetter(1),\n",
    "                                  reverse=True)\n",
    "        return sortedClassCount[0][0]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 选择信息增益最大特征的索引值\n",
    "函数说明：计算给定数据集的经验熵（香农熵）.\n",
    "\n",
    "Parameters：\n",
    ">    dataSet：数据集\n",
    "\n",
    "Returns：\n",
    ">    shannonEnt：信息增益最大特征的索引值\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-22T12:52:43.482974Z",
     "start_time": "2023-04-22T12:52:43.482642Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def chooseBestFeatureToSplit(dataSet):\n",
    "    \"\"\"\n",
    "\n",
    "    \"\"\"\n",
    "    # 特征数量(除去最后一行响应变量）\n",
    "    numFeatures = len(dataSet[0]) - 1\n",
    "    # 计数数据集的香农熵（响应变量的香农熵）\n",
    "    baseEntropy = calcShannonEnt(dataSet)  # 响应变量的香农熵\n",
    "    # 信息增益\n",
    "    bestInfoGain = 0.0\n",
    "    # 最优特征的索引值\n",
    "    bestFeature = -1\n",
    "    # 遍历所有特征\n",
    "    for i in range(numFeatures):\n",
    "        # 获取dataSet的第i个所有特征值\n",
    "        featList = [example[i] for example in dataSet]\n",
    "        # 创建set集合{}，元素不可重复，方便统计值为featList[i]的数量\n",
    "        uniqueVals = set(featList)\n",
    "        # 经验条件熵\n",
    "        newEntropy = 0.0\n",
    "        # 计算信息增益\n",
    "        for value in uniqueVals:\n",
    "            # subDataSet划分后的子集——删除了第i列\n",
    "            subDataSet = splitDataSet(dataSet, i, value)\n",
    "            ''''# print(subDataSet)\n",
    "            # print(len(subDataSet))\n",
    "            # print(type(subDataSet))\n",
    "            疑问：上述第一个print()输出含有15个元素的列表，\n",
    "            但是第二个print()结果为5——事实上这个结果应该是len(set(subDataSet))的结果'''\n",
    "\n",
    "            # 计算子集的概率\n",
    "            prob = len(subDataSet) / float(len(dataSet))\n",
    "            # print(prob,'\\n')\n",
    "            # 根据公式计算经验条件熵\n",
    "            newEntropy += prob * calcShannonEnt((subDataSet))\n",
    "        # 信息增益\n",
    "        infoGain = baseEntropy - newEntropy\n",
    "        # 打印每个特征的信息增益\n",
    "        print(\"第%d个特征的增益为%.3f\" % (i, infoGain))\n",
    "        # 计算信息增益\n",
    "        if (infoGain > bestInfoGain):\n",
    "            # 更新信息增益，找到最大的信息增益\n",
    "            bestInfoGain = infoGain\n",
    "            # 记录信息增益最大的特征的索引值\n",
    "            bestFeature = i\n",
    "            # 返回信息增益最大特征的索引值\n",
    "    return bestFeature\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 计算香农熵\n",
    "\n",
    "Parameters：\n",
    ">dataSet：数据集\n",
    "Returns：\n",
    ">shannonEnt：经验熵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-22T12:52:43.526168Z",
     "start_time": "2023-04-22T12:52:43.482683Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def calcShannonEnt(dataSet):\n",
    "    # 返回数据集行数,即样本数量\n",
    "    numEntries = len(dataSet)\n",
    "    # 保存每个标签（label）出现次数的字典\n",
    "    labelCounts = {}\n",
    "    # 对每组特征向量进行统计\n",
    "    for featVec in dataSet:\n",
    "        currentLabel = featVec[-1]  # 提取标签信息,最后一列数据，即响应变量的值,返回int类型\n",
    "        if currentLabel not in labelCounts.keys():  # 如果标签没有放入统计次数的字典，添加进去\n",
    "            labelCounts[currentLabel] = 0\n",
    "        labelCounts[currentLabel] += 1  # label计数\n",
    "\n",
    "    shannonEnt = 0.0  # 经验熵\n",
    "    # 计算经验熵\n",
    "    for key in labelCounts:\n",
    "        # 选择该标签的概率,labelCounts[key]是引用key对应的value值\n",
    "        prob = float(labelCounts[key]) / numEntries\n",
    "        shannonEnt -= prob * log(prob, 2)  # 利用公式计算\n",
    "    return shannonEnt  # 返回经验熵"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 划分数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-22T12:52:43.526336Z",
     "start_time": "2023-04-22T12:52:43.526050Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def splitDataSet(dataSet, axis, value):\n",
    "    # 创建返回的数据集列表\n",
    "    retDataSet = []\n",
    "    # 遍历数据集\n",
    "    for featVec in dataSet:\n",
    "        if featVec[axis] == value:\n",
    "            # 去掉axis特征\n",
    "            reduceFeatVec = featVec[:axis]\n",
    "            # 将符合条件的添加到返回的数据集\n",
    "            # 将每一行的featVec[axis + 1:]的特征加到reduceFeatVec后面\n",
    "            reduceFeatVec.extend(featVec[axis + 1:])\n",
    "            # 每一行去掉后加到retDataSet列表，相当于删除了第axis列的所有元素\n",
    "            retDataSet.append(reduceFeatVec)\n",
    "    # 返回划分后的数据集\n",
    "    return retDataSet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在已经可以得到决策树了，现在需要的是将其可视化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 可视化决策树"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## createPlot函数读入我们之前的到的决策树字典，将其可视化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-22T12:52:43.526427Z",
     "start_time": "2023-04-22T12:52:43.526101Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def createPlot(inTree):\n",
    "    \"\"\"\n",
    "    函数说明:创建绘制面板.\n",
    "\n",
    "    Parameters:\n",
    "        inTree - 决策树(字典)\n",
    "    Returns:\n",
    "        无\n",
    "    Modify:\n",
    "        2018-03-13\n",
    "    \"\"\"\n",
    "    fig = plt.figure(1, facecolor='white')  # 创建fig\n",
    "    fig.clf()  # 清空fig\n",
    "    axprops = dict(xticks=[], yticks=[])\n",
    "    createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)  # 去掉x、y轴\n",
    "    plotTree.totalW = float(getNumLeafs(inTree))  # 获取决策树叶结点数目\n",
    "    plotTree.totalD = float(getTreeDepth(inTree))  # 获取决策树层数\n",
    "    plotTree.xOff = -0.5 / plotTree.totalW\n",
    "    plotTree.yOff = 1.0  # x偏移\n",
    "    plotTree(inTree, (0.5, 1.0), '')  # 绘制决策树\n",
    "    plt.show()  # 显示绘制结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 得到树的深度 && 叶节点数目 && 节点的内容"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-22T12:52:43.538546Z",
     "start_time": "2023-04-22T12:52:43.526253Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def getTreeDepth(myTree):\n",
    "    \"\"\"\n",
    "    函数说明:获取决策树的层数.\n",
    "\n",
    "    Parameters:\n",
    "        myTree:决策树\n",
    "    Returns:\n",
    "        maxDepth:决策树的层数\n",
    "\n",
    "    Modify:\n",
    "        2018-03-13\n",
    "    \"\"\"\n",
    "    maxDepth = 0  # 初始化决策树深度\n",
    "    # python3中myTree.keys()返回的是dict_keys,不在是list,所以不能使用myTree.keys()[0]的方法获取结点属性，可以使用list(myTree.keys())[0]\n",
    "    firstStr = next(iter(myTree))\n",
    "    secondDict = myTree[firstStr]  # 获取下一个字典\n",
    "    for key in secondDict.keys():\n",
    "        # 测试该结点是否为字典，如果不是字典，代表此结点为叶子结点\n",
    "        if type(secondDict[key]).__name__ == 'dict':\n",
    "            thisDepth = 1 + getTreeDepth(secondDict[key])\n",
    "        else:\n",
    "            thisDepth = 1\n",
    "        # 更新层数\n",
    "        if thisDepth > maxDepth:\n",
    "            maxDepth = thisDepth\n",
    "    return maxDepth\n",
    "\n",
    "def getNumLeafs(myTree):\n",
    "    \"\"\"\n",
    "    函数说明：获取决策树叶子节点的数目.\n",
    "\n",
    "    Parameters：\n",
    "        myTree：决策树\n",
    "    Returns：\n",
    "        numLeafs：决策树的叶子节点的数目\n",
    "    Modify：\n",
    "        2018-03-13\n",
    "\n",
    "    \"\"\"\n",
    "    numLeafs = 0\n",
    "    firstStr = next(iter(myTree))\n",
    "    secondDict = myTree[firstStr]\n",
    "    for key in secondDict.keys():\n",
    "        if type(secondDict[key]).__name__ == 'dict':\n",
    "            numLeafs += getNumLeafs(secondDict[key])\n",
    "        else:\n",
    "            numLeafs += 1\n",
    "    return numLeafs\n",
    "\n",
    "def plotMidText(cntrPt, parentPt, txtString):\n",
    "    \"\"\"\n",
    "    函数说明:标注有向边属性值.\n",
    "\n",
    "    Parameters:\n",
    "        cntrPt、parentPt - 用于计算标注位置\n",
    "        txtString - 标注的内容\n",
    "    Returns:\n",
    "        无\n",
    "    Modify:\n",
    "        2018-03-13\n",
    "    \"\"\"\n",
    "    xMid = (parentPt[0] - cntrPt[0]) / 2.0 + cntrPt[0]  # 计算标注位置\n",
    "    yMid = (parentPt[1] - cntrPt[1]) / 2.0 + cntrPt[1]\n",
    "    createPlot.ax1.text(xMid, yMid, txtString, va=\"center\",\n",
    "                        ha=\"center\", rotation=30)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 画出树\n",
    "根据上面得到的内容，画出树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-22T12:52:43.586127Z",
     "start_time": "2023-04-22T12:52:43.542557Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "def plotTree(myTree, parentPt, nodeTxt):\n",
    "    \"\"\"\n",
    "    函数说明:绘制决策树.\n",
    "\n",
    "    Parameters:\n",
    "        myTree - 决策树(字典)\n",
    "        parentPt - 标注的内容\n",
    "        nodeTxt - 结点名\n",
    "    Returns:\n",
    "        无\n",
    "    Modify:\n",
    "        2018-03-13\n",
    "    \"\"\"\n",
    "    decisionNode = dict(boxstyle=\"sawtooth\", fc=\"0.8\")  # 设置结点格式\n",
    "    leafNode = dict(boxstyle=\"round4\", fc=\"0.8\")  # 设置叶结点格式\n",
    "    numLeafs = getNumLeafs(myTree)  # 获取决策树叶结点数目，决定了树的宽度\n",
    "    firstStr = next(iter(myTree))  # 下个字典\n",
    "    cntrPt = (plotTree.xOff + (1.0 + float(numLeafs)) / 2.0 / plotTree.totalW,\n",
    "              plotTree.yOff)  # 中心位置\n",
    "    plotMidText(cntrPt, parentPt, nodeTxt)  # 标注有向边属性值\n",
    "    plotNode(firstStr, cntrPt, parentPt, decisionNode)  # 绘制结点\n",
    "    secondDict = myTree[firstStr]  # 下一个字典，也就是继续绘制子结点\n",
    "    plotTree.yOff = plotTree.yOff - 1.0 / plotTree.totalD  # y偏移\n",
    "    for key in secondDict.keys():\n",
    "        # 测试该结点是否为字典，如果不是字典，代表此结点为叶子结点\n",
    "        if type(secondDict[key]).__name__ == 'dict':\n",
    "            plotTree(secondDict[key], cntrPt, str(key))  # 不是叶结点，递归调用继续绘制\n",
    "        else:  # 如果是叶结点，绘制叶结点，并标注有向边属性值\n",
    "            plotTree.xOff = plotTree.xOff + 1.0 / plotTree.totalW\n",
    "            plotNode(secondDict[key], (plotTree.xOff, plotTree.yOff),\n",
    "                     cntrPt, leafNode)\n",
    "            plotMidText((plotTree.xOff, plotTree.yOff), cntrPt, str(key))\n",
    "    plotTree.yOff = plotTree.yOff + 1.0 / plotTree.totalD\n",
    "\n",
    "def plotNode(nodeTxt, centerPt, parentPt, nodeType):\n",
    "    \"\"\"\n",
    "    函数说明:绘制结点.\n",
    "\n",
    "    Parameters:\n",
    "        nodeTxt - 结点名\n",
    "        centerPt - 文本位置\n",
    "        parentPt - 标注的箭头位置\n",
    "        nodeType - 结点格式\n",
    "    Returns:\n",
    "        无\n",
    "    Modify:\n",
    "        2018-03-13\n",
    "    \"\"\"\n",
    "    arrow_args = dict(arrowstyle=\"<-\")  # 定义箭头格式\n",
    "    # 设置中文字体\n",
    "    font = FontProperties(\n",
    "        fname=r\"/usr/share/fonts/winfonts/STSONG.TTF\", size=14)\n",
    "    # 绘制结点\n",
    "    createPlot.ax1.annotate(nodeTxt, xy=parentPt, xycoords='axes fraction',\n",
    "                            xytext=centerPt, textcoords='axes fraction',\n",
    "                            va=\"center\", ha=\"center\", bbox=nodeType,\n",
    "                            arrowprops=arrow_args, fontproperties=font)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 执行主函数代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-22T12:52:43.689995Z",
     "start_time": "2023-04-22T12:52:43.586014Z"
    },
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第0个特征的增益为0.083\n",
      "第1个特征的增益为0.324\n",
      "第2个特征的增益为0.420\n",
      "第3个特征的增益为0.363\n",
      "第0个特征的增益为0.252\n",
      "第1个特征的增益为0.918\n",
      "第2个特征的增益为0.474\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if \"__main__\" == __name__:\n",
    "    main()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
